
    //当前字符位的unicode > 255,那么该字节字符长度为2
    //当前字符位的unicode < 255,为1
    //charcodeAt 当前字符位的unicode


<!-- <script type="text/javascript">
    var str = 'asd老';
    function byteLength(str){
        var count = str.length;
        for (var i = 0;i < str.length;i ++){
            if(str.charCodeAt(i) > 255){
                count ++;
            }
        }
    }
</script> -->

<script type="text/javascript">
    var str = 'asd阿a';
    function byteLength(str){
        var count = 0;
        for(var i = 0; i < str.length; i ++){
            if(str.charCodeAt(i)>255){
                count += 2;
            }else{
                count ++;
            }
            return count;
        }
    }
    
</script>

构造函数通过多次调用，可以产生多个且独立的对象

//原型是function对象的一个属性，它定义了构造函数制造出的对象的公共祖先。通过该构造函数产生的对像，可以继承该原型的属性和方法。原型也是对象
<script type="text/javascript">
    //Person.prototype  -- 原型
    //Person.prototype{} 是祖先，空对象
    Person.prototype.name = 'hehe';
    Person.prototype.say = function(){console.log('123')};
    function Person(){

    }
    var person = new Person();//晚辈能继承前辈属性
    var person1 = new Person();
</script>

<script type="text/javascript">
    Person.prototype = {
        height :1400,
        lang : 4800,
        carName : 'BMW' 
    }


</script>

<script type="text/javascript">
     function Person (){};
     Car.prototype = {
        constructor : Person
     }
     function Car(){};
     var car = new Car();
</script>

<script type="text/javascript">
    Person.prototype.name = 'sunny';
    function Person(){

    }
    var person = new Person();
    Person.prototype.name = 'cherry';
</script>

<script type="text/javascript">
    var obj = {name : 'a'};
    var obj1 = obj;
    obj = {name : 'b'};
</script>

<script type="text/javascript">
    Person.prototype.name = 'sunny';
    function Person(){};// var this = {__proto__ :Person.prototype}
    var Person = new Person();
    Person.prototype = {
        name : 'cherry'
    };
    //person.prototype = {name : 'a'};
    //__proto__ = Person.prototype;
    //Person.prototype = {name : 'b'};
</script>

原型只是继承的一种方法，但是实现不了工业化的程度

继承发展史
1.传统形式
原型链     过多的继承了没用的属性

<script type="text/javascript">
    var Grand.prototype.lastName = 'hehe';
    function Grand(){}

    var grand = new Grand();

    Father.prototype = grand;
    function Father(){} 

    var father = new Father();

    Son.prototype = father;
    function Son(){}

    var son = new Son();//原型链，不想继承的属性也继承来了

</script>

2.借用构造函数，call和apply的应用,实现方法的借用
不能继承借用构造函数的原型
每次构造函数都要多走一个函数

3.共享原型
不能随便改动自己的原型
<script type="text/javascript">
    Father.prototype.lastName = 'das';
    function Father(){}

    function Son(){}

    Son.prototype = Father.prototype;//多个构造函数公用一个原型
    var son = new Son();
    var father = new Father();


</script>

//抽象出一个函数，封装成一个功能，函数就代表功能，函数待变功能的复用
<script type="text/javascript">
    //实现一个功能：不是让对象继承，让构造函数继承，让对象继承，改对象的__proto__即可；让构造函数构造出的对象，都改变继承的指向；让构造函数的prototype来更换
    function inherit(Target,Origin){//target继承origin
        Target.prototype = Origin.prototype;
    }

    Father.prototype.lastName = 'das';
    function Father(){}

    function Son(){}

    inherit(Son,Father);

    Son.prototype.sex = 'male';//会修改Father.prototype,想给son添加一个独特的自己的东西，但会影响自己的father


    var son = new Son();
    var father = new Father();
</script>

<script type="text/javascript">
    Father.prototype;//两方的公有原型，Father和F的公有原型

    function F(){}//F充当一个中间层
    F.prototype = Father.prototype

    //Son和F通过原型链的方式形成关系
    Son.prototype = new F();//给Son的prototype添加属性，不会影响Father,既能改自己的prototype，又能继承Father.prototype
</script>

//圣杯模式
<script type="text/javascript">
    function inherit(Target,Origin){
        function F(){};
        F.prototype = Origin.prototype;
        Target.prototype = new F();
        Target.prototype.constructor = Target;//指向紊乱，把Son的constructor归位,让Son访问的constructor就是它自己
        //希望我门的构造函数找到自己的超类，超级父级，实际上继承的还是Father
        Target.prototype.uber = Origin.prototype;//超类，找到它真正的继承
    }

    Father.prototype.lastName = 'fgd';
    function Father(){}
    function Son(){}

    inherit(Son,Father);
    Son.prototype.sex = 'male';

    var son = new Son();
    var father = new Father();

    console.log(son.sex);
    console.log(father.sex);
    console.log(Father.prototype);

    console.log(son.constructor);
    //son.__proto__ --> new F().__proto__ -->Father.prototype 

    
</script>